﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using AvaliacaoOnline.Model;
using AvaliacaoOnline.Data;
using System.IO;
using System.Configuration;

namespace Avaliacao.Controllers
{
    public class AvaliacaoController : BaseController
    {
        public ActionResult List(int? IdCliente)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }
            if (!IdCliente.HasValue)
                IdCliente = 0;

            List<Cliente> clientes = new ClienteRepository().GetClientes();
            ViewData["Clientes"] = clientes.Select(c => new SelectListItem()
            {
                Text = c.Nome,
                Value = c.Id.ToString(),
                Selected = IdCliente == c.Id
            }).ToList();


            if (clientes.Count == 0)
                return View();

            if (IdCliente.Value == 0)
                IdCliente = clientes.First().Id;

            List<AvaliacaoOnline.Data.Avaliacao> avaliacoes = new AvaliacaoRepository().GetAvaliacoes(IdCliente.Value);

            return View("List", avaliacoes);
        }

        [AcceptVerbs(HttpVerbs.Get)]
        public ActionResult Edit()
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            return Edit(-1);
        }

        public ActionResult Edit(int id)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            AvaliacaoRepository avaliacaoRepository = new AvaliacaoRepository();

            var avaliacao = avaliacaoRepository.GetAvaliacao(id);

            if (avaliacao != null)
                ViewData["PathInfo"] = UploadService.GetUploadPath(Server.MapPath("~/"), avaliacao.IdCliente, avaliacao.Id);
                

            return Edit(avaliacao);
        }

        private ActionResult Edit(AvaliacaoOnline.Data.Avaliacao avaliacao)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            AvaliacaoRepository avaliacaoRepository = new AvaliacaoRepository();

            List<Cliente> clientes = new ClienteRepository().GetClientes();
            ViewData["Clientes"] = clientes.Select(c => new SelectListItem()
            {
                Text = c.Nome,
                Value = c.Id.ToString(),
                Selected = (avaliacao == null) ? false : avaliacao.IdCliente == c.Id
            }).ToList();

            //prepara avaliacao nova se for o caso
            if (avaliacao == null)
            {
                avaliacao = new AvaliacaoOnline.Data.Avaliacao();
                avaliacao.Id = 0;
                avaliacao.DataInicial = DateTime.Now.NormalizeDate();
                avaliacao.DataFinal = DateTime.Now.NormalizeDate().AddDays(7);
            }
            else
            {
                AvaliacaoService avaliacaoService = new AvaliacaoService();
                ViewData["ImagemFundoURL"] = Url.Content("~" + avaliacaoService.GetImagemFundoURL(("/"), avaliacao.Id));
                ViewData["ArquivoEstiloURL"] = Url.Content("~" + avaliacaoService.GetArquivoEstiloURL(("/"), avaliacao.Id));
            }

            return View("Edit", avaliacao);
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult Upload(int idAvaliacao, int idCliente, string tipo)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            HttpPostedFileBase postedFile = Request.Files[0];
            postedFile.SaveAs(
                UploadService.GetUploadPath(Server.MapPath("~/"), idCliente, idAvaliacao)
                + Path.GetFileName(postedFile.FileName));

            AvaliacaoRepository repository = new AvaliacaoRepository();
            if (tipo == "1")
                repository.AtualizarImagemFundo(idAvaliacao, postedFile.FileName);
            else if (tipo == "2")
                repository.AtualizarArquivoEstilo(idAvaliacao, postedFile.FileName);


            AvaliacaoService avaliacaoService = new AvaliacaoService();
            String sUrl = "";
            if (tipo == "1")
                sUrl = Url.Content("~" + avaliacaoService.GetImagemFundoURL((@"/"), idAvaliacao));
            else
                sUrl = Url.Content("~" + avaliacaoService.GetArquivoEstiloURL((@"/"), idAvaliacao));

            return new JsonResult()
            {
                Data = new
                {
                    Url = sUrl,
                    Name = postedFile.FileName
                }
            };
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult UploadQuestao(int idQuestao, int idAvaliacao, int tipo)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            var avaliacao = new AvaliacaoRepository().GetAvaliacao(idAvaliacao);

            HttpPostedFileBase postedFile = Request.Files[0];
            postedFile.SaveAs(
                UploadService.GetUploadPath(Server.MapPath("~/"), avaliacao.IdCliente, idAvaliacao, idQuestao)
                + Path.GetFileName(postedFile.FileName));

            AvaliacaoRepository repository = new AvaliacaoRepository();

            repository.AtualizarArquivoQuestao(idQuestao, tipo, postedFile.FileName);

            return new JsonResult();
        }

        [ValidateInput(false)]
        public JsonResult Questoes(int idAvaliacao, string questoes)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                return new JsonResult();
            }

            try
            {
                List<QuestaoModelo> lstModelos = new AvaliacaoService().ParseQuestoes(questoes);

                AvaliacaoRepository avaliacaoRepository = new AvaliacaoRepository();
                string retorno = avaliacaoRepository.GravarQuestoes(idAvaliacao, lstModelos);

                return new JsonResult() { Data = "Processamento executado com sucesso.<br><br>" + retorno.Replace(Environment.NewLine, "<br>") };
            }
            catch (Exception ex)
            {
                return new JsonResult() { Data = ex.Message };
            }
        }

        [AcceptVerbs(HttpVerbs.Post)]
        [ValidateInput(false)]
        public ActionResult Save(AvaliacaoOnline.Data.Avaliacao avaliacao, string DataInicial, string DataFinal, string HoraInicial, string HoraFinal)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            AvaliacaoRepository repository = new AvaliacaoRepository();
            string erros = string.Empty;

            avaliacao.DataInicial = new DateTime(
                int.Parse(DataInicial.Substring(6, 4))
                , int.Parse(DataInicial.Substring(3, 2))
                , int.Parse(DataInicial.Substring(0, 2)));

            avaliacao.DataFinal = new DateTime(
                int.Parse(DataFinal.Substring(6, 4))
                , int.Parse(DataFinal.Substring(3, 2))
                , int.Parse(DataFinal.Substring(0, 2)));

            avaliacao.DataInicial = avaliacao.DataInicial.Add(new TimeSpan(int.Parse(HoraInicial.Split(new char[] { ':' })[0]), int.Parse(HoraInicial.Split(new char[] { ':' })[1]), 0));
            avaliacao.DataFinal = avaliacao.DataFinal.Add(new TimeSpan(int.Parse(HoraFinal.Split(new char[] { ':' })[0]), int.Parse(HoraFinal.Split(new char[] { ':' })[1]), 0));
            repository.GravarAvaliacao(avaliacao, ref erros);

            if (erros.Length > 0)
            {
                ViewData["Message"] = erros.Replace(Environment.NewLine, "<br>");
                return Edit(avaliacao);
            }
            else
            {
                ViewData["Message"] = "Avaliação atualizada com sucesso.";
                return Edit(avaliacao.Id);
            }
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult Delete(int idAvaliacao, int idCliente)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            AvaliacaoRepository repository = new AvaliacaoRepository();
            string erros = string.Empty;
            repository.ExcluirAvaliacao(idAvaliacao, ref erros);

            if (erros.Length > 0)
            {
                ViewData["Message"] = erros.Replace(Environment.NewLine, "<br>");
                return List(idCliente);
            }
            else
            {
                ViewData["Message"] = "Avaliação excluída com sucesso.";
                return List(idCliente);
            }

        }

        [ValidateInput(false)]
        public JsonResult SaveTextQuestao(int idQuestao, int numeroAlternativa, string descricao, string correta)
        {
            AvaliacaoRepository repository = new AvaliacaoRepository();
            repository.AtualizarDescricaoQuestao(idQuestao, numeroAlternativa, descricao, int.Parse(correta));
            return new JsonResult();
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public JsonResult ExcluirQuestao(int idQuestao, int numeroAlternativa)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return null;
            }

            AvaliacaoRepository repository = new AvaliacaoRepository();
            string erros = string.Empty;
            if (numeroAlternativa == 0)
                repository.ExcluirQuestao(idQuestao, ref erros);
            else
                repository.ExcluirAlternativa(idQuestao, numeroAlternativa, ref erros);

            var message = "";
            if (erros.Length > 0)
                ViewData["Message"] = erros.Replace(Environment.NewLine, "<br>");

            return new JsonResult()
            {
                Data = new { Message = message }
            };

        }

        public JsonResult ExcluirArquivo(int idAvaliacao, int tipo)
        {
            AvaliacaoRepository repository = new AvaliacaoRepository();
            if (tipo == 1)
                repository.AtualizarImagemFundo(idAvaliacao, null);
            else
                repository.AtualizarArquivoEstilo(idAvaliacao, null);
            return new JsonResult();
        }

        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult ExcluirArquivoQuestao(int idQuestao, int tipo)
        {
            if (Session["TipoUsuario"] as string != "A")
            {
                Response.Redirect(@"~\"); return View();
            }

            AvaliacaoRepository repository = new AvaliacaoRepository();

            repository.AtualizarArquivoQuestao(idQuestao, tipo, null);

            return new JsonResult();
        }
    }
}
